package ink.mint.activation;

public interface Activateable {

    /**
     * 激活函数解
     *
     * @param z              输入z
     * @param activationType 激活类型
     * @return 激活函数的解
     */
    double ActivationSolve(double z, ActivationType activationType);

    /**
     * 激活函数解
     *
     * @param z              输入z
     * @param activationType 激活类型
     * @return 激活函数的解
     */
    double[] ActivationSolve(double[] z, ActivationType activationType);

    /**
     * 激活函数解
     *
     * @param z              输入z
     * @param activationType 激活类型
     * @return 激活函数的解
     */
    double[][] ActivationSolve(double[][] z, ActivationType activationType);


    /**
     * 求导后的激活函数解
     *
     * @param z              输入z
     * @param activationType 激活类型
     * @return 激活函数的求导解
     */
    double derivationActivationSolve(double z, ActivationType activationType);

    /**
     * 求导后的激活函数解
     *
     * @param z              输入z
     * @param activationType 激活类型
     * @return 激活函数的求导解
     */
    double[] derivationActivationSolve(double[] z, ActivationType activationType);

    /**
     * 求导后的激活函数解
     *
     * @param z              输入z
     * @param activationType 激活类型
     * @return 激活函数的求导解
     */
    double[][] derivationActivationSolve(double[][] z, ActivationType activationType);

    /**
     * sigmoid 函数
     *
     * @param z 函数输入值
     * @return sigmoid函数解
     */
    double sigmoid(double z);

    /**
     * sigmoid 函数
     *
     * @param z 输入函数的向量
     * @return sigmoid函数向量解
     */
    double[] sigmoid(double[] z);

    /**
     * sigmoid 函数
     *
     * @param z 输入函数的矩阵
     * @return sigmoid函数矩阵解
     */
    double[][] sigmoid(double[][] z);

    /**
     * 求导后的sigmoid函数
     *
     * @param z 函数输入
     * @return 函数的解
     */
    double derivationSigmoid(double z);

    /**
     * 求导后的sigmoid函数
     *
     * @param z 输入函数的向量
     * @return 函数的向量解
     */
    double[] derivationSigmoid(double[] z);

    /**
     * 求导后的sigmoid函数
     *
     * @param z 输入函数的矩阵
     * @return 函数的矩阵解
     */
    double[][] derivationSigmoid(double[][] z);

    /**
     * relu函数
     *
     * @param z 函数输入的值
     * @return relu函数解
     */
    double relu(double z);

    /**
     * relu函数
     *
     * @param z 输入函数的向量值
     * @return relu函数向量解
     */
    double[] relu(double[] z);

    /**
     * relu函数
     *
     * @param z 输入函数的矩阵值
     * @return relu函数矩阵解
     */
    double[][] relu(double[][] z);

    /**
     * 求导后的relu函数
     *
     * @param z 输入函数的值
     * @return 求导后的relu函数解
     */
    double derivationRelu(double z);

    /**
     * 求导后的relu函数
     *
     * @param z 输入函数的向量值
     * @return 求导后的relu函数向量解
     */
    double[] derivationRelu(double[] z);

    /**
     * 求导后的relu函数
     *
     * @param z 输入函数的矩阵值
     * @return 求导后的relu函数矩阵解
     */
    double[][] derivationRelu(double[][] z);

    /**
     * softmax函数
     *
     * @param z 输入函数的值
     * @return softmax函数的解
     */
    double softmax(double z);

    /**
     * softmax函数
     *
     * @param z 输入函数的向量值
     * @return softmax函数的向量解
     */
    double[] softmax(double[] z);

    /**
     * softmax函数
     *
     * @param z 输入函数的矩阵值
     * @return softmax函数的矩阵解
     */
    double[][] softmax(double[][] z);

    /**
     * 求导后的softmax函数
     *
     * @param z 输入函数的值
     * @return 求导后的softmax函数解
     */
    double derivationSoftmax(double z);

    /**
     * 求导后的softmax函数
     *
     * @param z 输入函数的向量值
     * @return 求导后的softmax函数向量解
     */
    double[] derivationSoftmax(double[] z);

    /**
     * 求导后的softmax函数
     *
     * @param z 输入函数的矩阵值
     * @return 求导后的softmax函数矩阵解
     */
    double[][] derivationSoftmax(double[][] z);

    /**
     * tanh函数
     *
     * @param z 输入函数的值
     * @return tanh函数解
     */
    double tanh(double z);

    /**
     * tanh函数
     *
     * @param z 输入函数的向量值
     * @return tanh函数向量解
     */
    double[] tanh(double[] z);

    /**
     * tanh函数
     *
     * @param z 输入函数的矩阵值
     * @return tanh函数矩阵解
     */
    double[][] tanh(double[][] z);

    /**
     * 求导后的tanh函数
     *
     * @param z 输入函数的值
     * @return 求导后的tanh函数解
     */
    double derivationTanh(double z);

    /**
     * 求导后的tanh函数
     *
     * @param z 输入函数的向量值
     * @return 求导后的tanh函数向量解
     */
    double[] derivationTanh(double[] z);

    /**
     * 求导后的tanh函数
     *
     * @param z 输入函数的矩阵值
     * @return 求导后的tanh函数矩阵解
     */
    double[][] derivationTanh(double[][] z);
}
